#include <stdio.h>
#include <stdint.h>
#include "code.h"
int main(int argc,char* argv[])
{
    int fd = 1;
    int fs = 2;
    int ft = 3;
    int rs = 4;
    int rd = 5;
    int rt = 6;
    int imm = 4;
    uint32_t code[1000];
    uint8_t* p = (uint8_t*)code;
    mips32_nop(p);
    mips32_ssnop(p);
    mips32_ehb(p);
    mips32_add(p,rs,rt,rd);
    mips32_addu(p,rs,rt,rd);
    mips32_and(p,rs,rt,rd);
    mips32_break(p);
    mips32_cfc1(p,rt,rd);
    mips32_clz(p,rs,rt,rd);
    mips32_ctc1(p,rt,rd);
    mips32_div(p,rs,rt);
    mips32_divu(p,rs,rt);
    mips32_ext(p,rs,rt,rd);
    mips32_ins(p,rs,rt,rd);
    mips32_jr(p,rs);
    mips32_jr_hb(p,rs);
    mips32_jalr(p,rs);
    mips32_jalr_r(p,rs,rd);
    mips32_jalr_hb(p,rs);
    mips32_jalr_r_hb(p,rs,rd);
    mips32_ldxc1(p,rs,rt);
    mips32_madd(p,rs,rt);
    mips32_maddu(p,rs,rt);
    mips32_mfc1(p,rt,rd);
    mips32_mfhc1(p,rt,rd);
    mips32_mfhi(p,rd);
    mips32_movf(p,rs,rd);
    mips32_movn(p,rs,rt,rd);
    mips32_movz(p,rs,rt,rd);
    mips32_msub(p,rs,rt);
    mips32_msubu(p,rs,rt);
    mips32_mtc1(p,rt,rd);
    mips32_mthc1(p,rt,rd);
    mips32_mtlo(p,rs);
    mips32_mul(p,rs,rt,rd);
    mips32_mult(p,rs,rt);
    mips32_multu(p,rs,rt);
    mips32_nor(p,rs,rt,rd);
    mips32_or(p,rs,rt,rd);
    mips32_seb(p,rt,rd);
    mips32_seh(p,rt,rd);
    mips32_sllv(p,rs,rt,rd);
    mips32_slt(p,rs,rt,rd);
    mips32_sltu(p,rs,rt,rd);
    mips32_srav(p,rs,rt,rd);
    mips32_sub(p,rs,rt,rd);
    mips32_subu(p,rs,rt,rd);
    mips32_sync(p);
    mips32_syscall(p);
    mips32_teq(p,rs,rt);
    mips32_tge(p,rs,rt);
    mips32_tgeu(p,rs,rt);
    mips32_tlt(p,rs,rt);
    mips32_tltu(p,rs,rt);
    mips32_tne(p,rs,rt);
    mips32_wsbh(p,rt,rd);
    mips32_xor(p,rs,rt,rd);
    mips32_sll(p,rt,rd,imm);
    mips32_sra(p,rt,rd,imm);
    mips32_srl(p,rt,rd,imm);
    mips32_abs_s(p,fs,fd);
    mips32_abs_d(p,fs,fd);
    mips32_abs_ps(p,fs,fd);
    mips32_add_s(p,fs,ft,fd);
    mips32_add_d(p,fs,ft,fd);
    mips32_add_ps(p,fs,ft,fd);
    mips32_alnv_ps(p,fs,ft,fd);
    mips32_c_f_d(p,fs,ft);
    mips32_c_f_s(p,fs,ft);
    mips32_c_f_ps(p,fs,ft);
    mips32_c_un_d(p,fs,ft);
    mips32_c_un_s(p,fs,ft);
    mips32_c_un_ps(p,fs,ft);
    mips32_c_eq_d(p,fs,ft);
    mips32_c_eq_s(p,fs,ft);
    mips32_c_eq_ps(p,fs,ft);
    mips32_c_ueq_d(p,fs,ft);
    mips32_c_ueq_s(p,fs,ft);
    mips32_c_ueq_ps(p,fs,ft);
    mips32_c_olt_d(p,fs,ft);
    mips32_c_olt_s(p,fs,ft);
    mips32_c_olt_ps(p,fs,ft);
    mips32_c_ole_d(p,fs,ft);
    mips32_c_ole_s(p,fs,ft);
    mips32_c_ole_ps(p,fs,ft);
    mips32_c_ule_d(p,fs,ft);
    mips32_c_ule_s(p,fs,ft);
    mips32_c_ule_ps(p,fs,ft);
    mips32_c_sf_d(p,fs,ft);
    mips32_c_sf_s(p,fs,ft);
    mips32_c_sf_ps(p,fs,ft);
    mips32_c_ngle_d(p,fs,ft);
    mips32_c_ngle_s(p,fs,ft);
    mips32_c_ngle_ps(p,fs,ft);
    mips32_c_seq_d(p,fs,ft);
    mips32_c_seq_s(p,fs,ft);
    mips32_c_seq_ps(p,fs,ft);
    mips32_c_ngl_d(p,fs,ft);
    mips32_c_ngl_s(p,fs,ft);
    mips32_c_ngl_ps(p,fs,ft);
    mips32_c_lt_d(p,fs,ft);
    mips32_c_lt_s(p,fs,ft);
    mips32_c_lt_ps(p,fs,ft);
    mips32_c_nge_d(p,fs,ft);
    mips32_c_nge_s(p,fs,ft);
    mips32_c_nge_ps(p,fs,ft);
    mips32_c_le_d(p,fs,ft);
    mips32_c_le_s(p,fs,ft);
    mips32_c_le_ps(p,fs,ft);
    mips32_c_ngt_d(p,fs,ft);
    mips32_c_ngt_s(p,fs,ft);
    mips32_c_ngt_ps(p,fs,ft);
    mips32_ceil_l_d(p,fs,fd);
    mips32_ceil_l_s(p,fs,fd);
    mips32_ceil_w_d(p,fs,fd);
    mips32_ceil_w_s(p,fs,fd);
    mips32_cvt_d_l(p,fs,fd);
    mips32_cvt_d_s(p,fs,fd);
    mips32_cvt_d_w(p,fs,fd);
    mips32_cvt_l_d(p,fs,fd);
    mips32_cvt_l_s(p,fs,fd);
    mips32_cvt_s_pl(p,fs,fd);
    mips32_cvt_s_pu(p,fs,fd);
    mips32_cvt_w_d(p,fs,fd);
    mips32_cvt_w_s(p,fs,fd);
    mips32_cvt_ps_s(p,fs,ft,fd);
    mips32_div_d(p,fs,ft,fd);
    mips32_div_s(p,fs,ft,fd);
    mips32_floor_l_d(p,fs,fd);
    mips32_floor_l_s(p,fs,fd);
    mips32_floor_w_d(p,fs,fd);
    mips32_floor_w_s(p,fs,fd);
    mips32_madd_d(p,fs,ft,fd);
    mips32_madd_s(p,fs,ft,fd);
    mips32_madd_ps(p,fs,ft,fd);
    mips32_mov_d(p,fs,fd);
    mips32_mov_s(p,fs,fd);
    mips32_mov_ps(p,fs,fd);
    mips32_movf_d(p,fs,fd);
    mips32_movf_s(p,fs,fd);
    mips32_movf_ps(p,fs,fd);
    mips32_movn_d(p,fs,ft,fd);
    mips32_movn_s(p,fs,ft,fd);
    mips32_movn_ps(p,fs,ft,fd);
    mips32_movz_d(p,fs,ft,fd);
    mips32_movz_s(p,fs,ft,fd);
    mips32_movz_ps(p,fs,ft,fd);
    mips32_msub_d(p,fs,ft,fd);
    mips32_msub_s(p,fs,ft,fd);
    mips32_msub_ps(p,fs,ft,fd);
    mips32_mul_d(p,fs,ft,fd);
    mips32_mul_s(p,fs,ft,fd);
    mips32_mul_ps(p,fs,ft,fd);
    mips32_round_l_d(p,fs,fd);
    mips32_round_l_s(p,fs,fd);
    mips32_round_w_d(p,fs,fd);
    mips32_round_w_s(p,fs,fd);
    mips32_rsqrt_d(p,fs,fd);
    mips32_rsqrt_s(p,fs,fd);
    mips32_sqrt_d(p,fs,fd);
    mips32_sqrt_s(p,fs,fd);
    mips32_trunc_l_d(p,fs,fd);
    mips32_trunc_l_s(p,fs,fd);
    mips32_trunc_w_d(p,fs,fd);
    mips32_trunc_w_s(p,fs,fd);
    mips32_pref(p,rt,rs,imm);
    mips32_b(p,imm);
    mips32_bal(p,imm);
    mips32_addi(p,rt,rs,imm);
    mips32_addiu(p,rt,rs,imm);
    mips32_bc1f(p,imm);
    mips32_bc1fl(p,imm);
    mips32_bc1t(p,imm);
    mips32_bc1tl(p,imm);
    mips32_beq(p,rt,rs,imm);
    mips32_beql(p,rt,rs,imm);
    mips32_bgez(p,rs,imm);
    mips32_bgezl(p,rs,imm);
    mips32_bgezal(p,rs,imm);
    mips32_bgezall(p,rs,imm);
    mips32_bgtz(p,rs,imm);
    mips32_bgtzl(p,rs,imm);
    mips32_blez(p,rs,imm);
    mips32_blezl(p,rs,imm);
    mips32_bltz(p,rs,imm);
    mips32_bltzl(p,rs,imm);
    mips32_bltzal(p,rs,imm);
    mips32_bltzall(p,rs,imm);
    mips32_bne(p,rt,rs,imm);
    mips32_bnel(p,rt,rs,imm);
    mips32_cache(p,rt,rs,imm);
    mips32_lbu(p,rt,rs,imm);
    mips32_ldc1(p,rt,rs,imm);
    mips32_ldc1(p,rt,rs,imm);
    mips32_ldc2(p,rt,rs,imm);
    mips32_lh(p,rt,rs,imm);
    mips32_lhu(p,rt,rs,imm);
    mips32_ll(p,rt,rs,imm);
    mips32_lui(p,rt,imm);
    mips32_lw(p,rt,rs,imm);
    mips32_lw(p,rt,rs,imm);
    mips32_lwl(p,rt,rs,imm);
    mips32_lwr(p,rt,rs,imm);
    mips32_ori(p,rt,rs,imm);
    mips32_sb(p,rt,rs,imm);
    mips32_sc(p,rt,rs,imm);
    mips32_sh(p,rt,rs,imm);
    mips32_slti(p,rt,rs,imm);
    mips32_sltiu(p,rt,rs,imm);
    mips32_sw(p,rt,rs,imm);
    mips32_swl(p,rt,rs,imm);
    mips32_swr(p,rt,rs,imm);
    mips32_synci(p,rs,imm);
    mips32_teqi(p,rs,imm);
    mips32_tgei(p,rs,imm);
    mips32_tgeiu(p,rs,imm);
    mips32_tlti(p,rs,imm);
    mips32_tltiu(p,rs,imm);
    mips32_tnei(p,rs,imm);
    mips32_xori(p,rt,rs,imm);
    mips32_bc2f(p,imm);
    mips32_bc2fl(p,imm);
    mips32_bc2tl(p,imm);
    mips32_j(p,imm);
    mips32_jal(p,imm);
    printf("asm volatile(\n");

    for(int i = 0;i < 225;i++) {
        printf("\".word 0x%08x \\t\\n\"\n",code[i]);
    }
    printf(")\n");
}
